home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 May: Tool Chest / Developer CD Series May 1996 (Tool Chest) (Apple Computer) (1996).iso / Tool Chest / Developer Utilities / Installer 4.0.3 SDK / Script Examples / Simple Atom Extender / DirectCopyExtender.c next >
Encoding:
C/C++ Source or Header  |  1994-11-15  |  17.3 KB  |  481 lines  |  [TEXT/MPS ]
  1.  
  2. #ifndef __Errors__
  3. #include <Errors.h>
  4. #endif
  5.  
  6. #ifndef __Memory__
  7. #include <Memory.h>
  8. #endif
  9.  
  10. #ifndef __OSUtils__
  11. #include <OSUtils.h>
  12. #endif
  13.  
  14. #ifndef __Packages__
  15. #include <Packages.h>
  16. #endif
  17.  
  18. #include <TextUtils.h>
  19.  
  20. #ifndef __AtomExtenderHeader__
  21. #include "AtomExtenderHeader.h"
  22. #endif
  23.  
  24. #ifndef __ActionHandlerHeader__
  25. #include "ActionHandlerHeader.h"
  26. #endif
  27.  
  28. void DisplayAtomExtenderInfo( ExtenderPBPtr        pExtenderPBPtr, ExtenderResultCode pResultCode );
  29.  
  30. ExtenderResultCode DirectCopyExtender( ExtenderPBPtr        pExtenderPBPtr )
  31. {
  32.     OSErr                theErr;
  33.     long                dataLen;
  34.     Ptr                    theBufferPtr;
  35.     ExtenderResultCode    resultCode;
  36.  
  37.     // -- Initalize some important variables
  38.     dataLen = 30000;
  39.     theErr = noErr;
  40.  
  41.     // -- Depending on the message, perform the proper task
  42.     switch( pExtenderPBPtr->fFileCopyPBRec.fEnvironmentHeader.fMessageID ) {
  43.  
  44.         case kBeforePart:
  45.         
  46.             // -- Create a buffer
  47.             theBufferPtr = NewPtr(dataLen);
  48.         
  49.             // -- Check that we got our buffer successfully
  50.             if( theBufferPtr != NULL && MemError() == noErr ) {
  51.         
  52.                 // -- Read as much as we can up to the size of the buffer.
  53.                 theErr = ReadSourceData( pExtenderPBPtr->fBasicPBRec.fEnvironmentHeader.fCallBackProcPtr, &dataLen, theBufferPtr);
  54.  
  55.                 // -- Loop while there is more data to read. 
  56.                 while( dataLen > 0 ) {
  57.         
  58.         
  59.                     // -- DO SOMETHING TO THE DATA HERE, LIKE DECOMPRESSION IF YOU NEED TO
  60.         
  61.         
  62.                     // -- Write the data out.
  63.                     theErr = WriteTargetData( pExtenderPBPtr->fBasicPBRec.fEnvironmentHeader.fCallBackProcPtr, dataLen, theBufferPtr);
  64.                     
  65.                     // -- Read as much as we can up to the size of the buffer.
  66.                     if( theErr == noErr ) {
  67.                         theErr = ReadSourceData( pExtenderPBPtr->fBasicPBRec.fEnvironmentHeader.fCallBackProcPtr, &dataLen, theBufferPtr);
  68.                         
  69.                         // -- If we got an eofErr, then we know we're done, and dataLen will be 0 (zero).
  70.                         if( theErr == eofErr )
  71.                             theErr = noErr;
  72.                     }
  73.  
  74.                 } // while not done copying
  75.  
  76.                 if( theErr == noErr )
  77.                     resultCode = kCopiedData;
  78.                 else
  79.                     resultCode = kFatalError;
  80.  
  81.                 // -- Dispose the buffer
  82.                 DisposPtr(theBufferPtr);
  83.             }
  84.             else
  85.                 resultCode = kFatalError;
  86.  
  87.             // Write some handy info to the Installer Debugger, if it is installed.
  88.             DisplayAtomExtenderInfo( pExtenderPBPtr, resultCode );
  89.             break;
  90.     
  91.         // -- We ignore the other messages.
  92.         case kInitialize:
  93.         case kAfterPart:    
  94.         case kSuccess:    
  95.         case kCancel:
  96.             resultCode = kContinueAsNormal;
  97.             break;
  98.     }
  99.     
  100.     return resultCode;
  101. }
  102.  
  103.  
  104.  
  105.  
  106.  
  107.  
  108. // -------------------------------------------------------------------------------------------------------------------------------------
  109. // The routines below are for displaying the contents of the parameter block passed to the Atom Extender.
  110. // Call DisplayAtomExtenderInfo to write this information to the Installer Debugger.
  111.  
  112. void MakeFilePath( FSSpec* pFileFSSpec, Str255  pFilePath )
  113. {
  114.     
  115.     CInfoPBRec        cPBRec;
  116.     Str255            directoryName = "";
  117.     short            i;
  118.     OSErr            theErr;
  119.  
  120.     // Get the file name
  121.     for( i=0;i<=pFileFSSpec->name[0];i++)
  122.         pFilePath[i] = pFileFSSpec->name[i];
  123.  
  124.     cPBRec.hFileInfo.ioCompletion = NULL;
  125.     cPBRec.hFileInfo.ioNamePtr = directoryName;
  126.     cPBRec.hFileInfo.ioFDirIndex = -1;
  127.     cPBRec.hFileInfo.ioDirID = pFileFSSpec->parID;
  128.     cPBRec.hFileInfo.ioVRefNum = pFileFSSpec->vRefNum;
  129.     theErr = PBGetCatInfo( &cPBRec, 0 );
  130.  
  131.     // Preappend directoryName
  132.     BlockMove( pFilePath + 1, pFilePath + directoryName[0] + 2, pFilePath[0] );
  133.     for( i=1;i<=directoryName[0];i++)
  134.         pFilePath[i] = directoryName[i];
  135.     pFilePath[i] = ':';
  136.     pFilePath[0] += directoryName[0] + 1;
  137.  
  138.     while ( theErr == noErr && cPBRec.dirInfo.ioDrParID != 1 && pFilePath[0] + directoryName[0] + 1 < 255 ) {
  139.  
  140.     // Preappend directoryName
  141.         cPBRec.hFileInfo.ioDirID = cPBRec.dirInfo.ioDrParID;
  142.         cPBRec.hFileInfo.ioFDirIndex = -1;
  143.         theErr = PBGetCatInfo( &cPBRec, 0 );
  144.  
  145.         if( theErr == noErr ) {
  146.             // Preappend directoryName
  147.             BlockMove( pFilePath + 1, pFilePath + directoryName[0] + 2, pFilePath[0] );
  148.             for( i=1;i<=directoryName[0];i++)
  149.                 pFilePath[i] = directoryName[i];
  150.             pFilePath[i] = ':';
  151.             pFilePath[0] += directoryName[0] + 1;
  152.         }
  153.     }
  154.  
  155. }
  156.  
  157. void PrintLine( ProcPtr pCallBackProcPtr, Str255 pParam0, Str255 pParam1, Str255 pParam2, Str255 pParam3 )
  158. {
  159.     long    theResult;
  160.     RegisterScriptAction( pCallBackProcPtr, kDebuggingAction, kGenericDebugActID, pParam0, pParam1, pParam2, pParam3, &theResult );    
  161. }
  162.  
  163. void DisplayAtomExtenderInfo( ExtenderPBPtr        pExtenderPBPtr, ExtenderResultCode pResultCode )
  164. {
  165.  
  166. StringPtr                    kBeginCallPart1                    = "\p=>========================== Begin Atom Extender Call ==== ";
  167. StringPtr                    kBeginCallPart3                    = "\p============================";
  168.  
  169. StringPtr                    kEndCallPart1                    = "\p-<-------------------------- End Atom Extender Call ------ ";
  170. StringPtr                    kEndCallPart3                    = "\p----------------------------\n";
  171.  
  172. StringPtr                    kRefConText                        = "\pRefCon: ";
  173.  
  174. StringPtr                    kTargetVolNumText                = "\p    TargetVolumeRefNum:  ";
  175. StringPtr                    kTargetBlessedDirIDText            = "\p    TargetBlessedDirID:  ";
  176. StringPtr                    kBootVolNumText                    = "\p      BootVolumeRefNum:  ";
  177. StringPtr                    kBootBlessedDirIDText            = "\p      BootBlessedDirID:  ";
  178.  
  179. StringPtr                    kInitializeText                    = "\pInitialization Call =";
  180. StringPtr                    kSuccessText                    = "\pSuccessful Completion";
  181. StringPtr                    kBeforePartText                    = "\pBefore Part =========";
  182. StringPtr                    kAfterPartText                    = "\pAfter Part ==========";
  183. StringPtr                    kCancelText                        = "\pCANCELIZATION CALL ==";
  184.  
  185. StringPtr                    kOkRtnMessageText                ="\pContinue result returned --";
  186. StringPtr                    kCancelRtnMessageText            ="\pCancel result returned ----";
  187. StringPtr                    kErrorRtnMessageText            ="\pError result returned -----";
  188. StringPtr                    kCopiedDataMessageText            ="\pCopied Data result returned";
  189.  
  190. StringPtr                    kFileAtomDataForkText            = "\pDataType:  FileAtomDataFork";
  191. StringPtr                    kFileAtomRsrcForkText            = "\pDataType:  FileAtomRsrcFork";
  192. StringPtr                    kFileAtomRsrcForkFromDataForkText= "\pDataType:  FileAtomRsrcForkFromDataFork";
  193. StringPtr                    kRsrcAtomText                    = "\pDataType:  RsrcAtom";
  194. StringPtr                    kFontAtomText                    = "\pDataType:  FontAtom";
  195. StringPtr                    kActionAtomText                    = "\pDataType:  N/A";
  196.  
  197. StringPtr                    kSourceFileText                    = "\pSource Info...  ";
  198. StringPtr                    kTargetFileText                    = "\pTarget Info...  ";
  199. StringPtr                    kFSSpecNameText                    = "\p      File Path:  ";
  200. StringPtr                    kPartSizeText                    = "\p      Part Size:  ";
  201. StringPtr                    kPosSizeText                    = "\p      Start Pos:  ";
  202. StringPtr                    kTotalSizeText                    = "\p     Total Size:  ";
  203.  
  204. StringPtr                    kRsrcSourceRsrcTypeText            = "\p  Src Rsrc Type:  ";
  205. StringPtr                    kRsrcSourceRsrcIDText            = "\p    Src Rsrc ID:  ";
  206. StringPtr                    kRsrcTargetRsrcTypeText            = "\p  Tgt Rsrc Type:  ";
  207. StringPtr                    kRsrcTargetRsrcIDText            = "\p    Tgt Rsrc ID:  ";
  208. StringPtr                    kRsrcTargetRsrcNameText            = "\p      Rsrc Name:  ";
  209. StringPtr                    kRsrcTargetRsrcAttrsText        = "\p     Rsrc Attrs:  ";
  210.  
  211. StringPtr                    kFontSourceRsrcTypeText            = "\p  Src Rsrc Type:  ";
  212. StringPtr                    kFontSourceRsrcIDText            = "\p    Src Rsrc ID:  ";
  213. StringPtr                    kFontTargetRsrcTypeText            = "\p  Tgt Rsrc Type:  ";
  214. StringPtr                    kFontTargetRsrcIDText            = "\p    Tgt Rsrc ID:  ";
  215. StringPtr                    kFontTargetRsrcNameText            = "\p      Rsrc Name:  ";
  216. StringPtr                    kFontTargetRsrcAttrsText        = "\p     Rsrc Attrs:  ";
  217. StringPtr                    kFontFamilyNameText                = "\p    Family Name:  ";
  218. StringPtr                    kFontFamilyIDText                = "\p      Family ID:  ";
  219. StringPtr                    kFontFontSizeText                = "\p      Font Size:  ";
  220. StringPtr                    kFontFontStyleText                = "\p     Font Style:  ";
  221.  
  222. StringPtr                    kInstallerTempDirIDText            = "\p Temp Directory:  ";
  223.  
  224. Str255                        tempNumStr;    
  225. Str255                        tempStr255;
  226. FSSpec                        tempFSSpec;
  227. ProcPtr                        theCallBackPtr = pExtenderPBPtr->fBasicPBRec.fEnvironmentHeader.fCallBackProcPtr;
  228.  
  229.  
  230. // -- BASIC STUFF ----------------------------------------------------------------------
  231.  
  232.     switch (pExtenderPBPtr->fBasicPBRec.fEnvironmentHeader.fMessageID) {
  233.         case kInitialize :        PrintLine( theCallBackPtr, kBeginCallPart1, kInitializeText, kBeginCallPart3, "\p" );
  234.                                 break;
  235.         case kSuccess :            PrintLine( theCallBackPtr, kBeginCallPart1, kSuccessText, kBeginCallPart3, "\p" );
  236.                                 break;
  237.         case kBeforePart :        PrintLine( theCallBackPtr, kBeginCallPart1, kBeforePartText, kBeginCallPart3, "\p" );
  238.                                 break;
  239.         case kAfterPart :        PrintLine( theCallBackPtr, kBeginCallPart1, kAfterPartText, kBeginCallPart3, "\p" );
  240.                                 break;
  241.         case kCancel :            PrintLine( theCallBackPtr, kBeginCallPart1, kCancelText, kBeginCallPart3, "\p" );
  242.                                 break;
  243.         }
  244.     
  245.     switch (pExtenderPBPtr->fBasicPBRec.fEnvironmentHeader.fMessageID) {
  246.         case kInitialize :
  247.         case kSuccess :
  248.         case kCancel :
  249.             NumToString( pExtenderPBPtr->fBasicPBRec.fEnvironmentHeader.fRefCon, &tempNumStr );
  250.             PrintLine( theCallBackPtr, kRefConText, tempNumStr, "\p", "\p" );
  251.             break;
  252.             
  253.         case kBeforePart :
  254.         case kAfterPart :
  255.             
  256.             NumToString( pExtenderPBPtr->fBasicPBRec.fEnvironmentHeader.fRefCon, &tempNumStr );
  257.             PrintLine( theCallBackPtr, kRefConText, tempNumStr, "\p", "\p" );
  258.                                 
  259.             switch (pExtenderPBPtr->fBasicPBRec.fEnvironmentHeader.fDataType) {
  260.                 case kFileAtomDataFork :                PrintLine( theCallBackPtr, kFileAtomDataForkText, "\p", "\p", "\p" );
  261.                                                         break;
  262.                 case kFileAtomRsrcFork :                PrintLine( theCallBackPtr, kFileAtomRsrcForkText, "\p", "\p", "\p" );
  263.                                                         break;
  264.                 case kFileAtomRsrcForkFromDataFork :    PrintLine( theCallBackPtr, kFileAtomRsrcForkFromDataForkText, "\p", "\p", "\p" );
  265.                                                         break;
  266.                 case kRsrcAtom :                        PrintLine( theCallBackPtr, kRsrcAtomText, "\p", "\p", "\p" );
  267.                                                         break;
  268.                 case kFontAtom :                        
  269.                                                         // -- Font Atom Description
  270.                                                         PrintLine( theCallBackPtr, kFontAtomText, "\p", "\p", "\p" );
  271.                                                     
  272.                                                         // -- Font Family Name
  273.                                                         PrintLine( theCallBackPtr, kFontFamilyNameText, pExtenderPBPtr->fFontCopyPBRec.fFamilyName, "\p", "\p" );
  274.                                     
  275.                                                         // -- Font Family ID
  276.                                                         NumToString( pExtenderPBPtr->fFontCopyPBRec.fFamilyID, &tempNumStr );
  277.                                                         PrintLine( theCallBackPtr, kFontFamilyIDText, tempNumStr, "\p", "\p" );
  278.                                                         
  279.                                                         // -- Font Strike Size
  280.                                                         NumToString( pExtenderPBPtr->fFontCopyPBRec.fFontSize, &tempNumStr );
  281.                                                         PrintLine( theCallBackPtr, kFontFontSizeText, tempNumStr, "\p", "\p" );
  282.                                                         
  283.                                                         // -- Font Strike Style
  284.                                                         NumToString( pExtenderPBPtr->fFontCopyPBRec.fFontStyle, &tempNumStr );
  285.                                                         PrintLine( theCallBackPtr, kFontFontStyleText, tempNumStr, "\p", "\p" );
  286.                                                         break;
  287.                     
  288.                 case kActionAtom :                        PrintLine( theCallBackPtr, kActionAtomText, "\p", "\p", "\p" );
  289.                                                         break;
  290.                 }
  291.                                 break;
  292.         }
  293.  
  294.  
  295. // -- BASIC SOURCE INFO ----------------------------------------------------------------------
  296.  
  297.     switch (pExtenderPBPtr->fBasicPBRec.fEnvironmentHeader.fMessageID) {
  298.          case kBeforePart :
  299.         case kAfterPart :
  300.         // -- SOURCE FILE ----------------------------------------------------------------------
  301.             // -- Source Title
  302.             PrintLine( theCallBackPtr, kSourceFileText, "\p", "\p", "\p" );
  303.         
  304.             MakeFilePath( &(pExtenderPBPtr->fBasicPBRec.fCopyPBHeader.fSourceFile), tempStr255 );
  305.             PrintLine( theCallBackPtr, kFSSpecNameText, tempStr255, "\p", "\p" );
  306.         
  307.             NumToString( pExtenderPBPtr->fBasicPBRec.fCopyPBHeader.fSourcePartSize, &tempNumStr );
  308.             PrintLine( theCallBackPtr, kPartSizeText, tempNumStr, "\p", "\p" );
  309.             break;
  310.         }
  311.     
  312. // -- ATOM SOURCE SPECIFIC INFO ----------------------------------------------------------------------
  313.  
  314.     switch (pExtenderPBPtr->fBasicPBRec.fEnvironmentHeader.fMessageID) {
  315.         case kInitialize :
  316.         case kSuccess :
  317.             break;
  318.         case kBeforePart :
  319.         case kAfterPart :
  320.             switch (pExtenderPBPtr->fBasicPBRec.fEnvironmentHeader.fDataType) {
  321.                 case kFileAtomDataFork :
  322.                 case kFileAtomRsrcFork :
  323.                 case kFileAtomRsrcForkFromDataFork :
  324.                     break;
  325.                 case kRsrcAtom :
  326.                     // -- Resource Source Type
  327.                     BlockMove( &(pExtenderPBPtr->fRsrcCopyPBRec.fSourceRsrcType), &(tempStr255[2]), 4 );
  328.                     tempStr255[1] = '\'';
  329.                     tempStr255[6] = '\'';
  330.                     tempStr255[0] = 6;
  331.                     PrintLine( theCallBackPtr, kRsrcSourceRsrcTypeText, tempStr255, "\p", "\p" );
  332.                     
  333.                     // -- Resource Source ID
  334.                     NumToString( pExtenderPBPtr->fRsrcCopyPBRec.fSourceRsrcID, &tempNumStr );
  335.                     PrintLine( theCallBackPtr, kRsrcSourceRsrcIDText, tempNumStr, "\p", "\p" );
  336.  
  337.                     break;
  338.                 case kFontAtom :
  339.                     // -- Font Source Type
  340.                     BlockMove( &(pExtenderPBPtr->fFontCopyPBRec.fSourceFontRsrcType), &(tempStr255[2]), 4 );
  341.                     tempStr255[1] = '\'';
  342.                     tempStr255[6] = '\'';
  343.                     tempStr255[0] = 6;
  344.                     PrintLine( theCallBackPtr, kFontSourceRsrcTypeText, tempStr255, "\p", "\p" );
  345.                 
  346.                     // -- Font Source ID
  347.                     NumToString( pExtenderPBPtr->fFontCopyPBRec.fSourceFontRsrcID, &tempNumStr );
  348.                     PrintLine( theCallBackPtr, kFontSourceRsrcIDText, tempNumStr, "\p", "\p" );
  349.  
  350.                     break;
  351.                 default :
  352.                     break;
  353.                 }
  354.             break;
  355.         case kCancel :
  356.                 break;
  357.         }
  358.  
  359.  
  360. // -- BASIC TARGET INFO ----------------------------------------------------------------------
  361.  
  362.     switch (pExtenderPBPtr->fBasicPBRec.fEnvironmentHeader.fMessageID) {
  363.          case kBeforePart :
  364.         case kAfterPart :
  365.         
  366.         // -- TARGET FILE ----------------------------------------------------------------------
  367.             // -- Target Title
  368.             PrintLine( theCallBackPtr, kTargetFileText, "\p", "\p", "\p" );
  369.         
  370.             // -- Target File Name
  371.             MakeFilePath( &(pExtenderPBPtr->fBasicPBRec.fCopyPBHeader.fTargetFile), tempStr255 );
  372.             PrintLine( theCallBackPtr, kFSSpecNameText, tempStr255, "\p", "\p" );
  373.         
  374.             // -- Target Start Position
  375.             NumToString( pExtenderPBPtr->fBasicPBRec.fCopyPBHeader.fTargetPosStart, &tempNumStr );
  376.             PrintLine( theCallBackPtr, kPosSizeText, tempNumStr, "\p", "\p" );
  377.         
  378.             // -- Target Part Size
  379.             NumToString( pExtenderPBPtr->fBasicPBRec.fCopyPBHeader.fTargetPartSize, &tempNumStr );
  380.             PrintLine( theCallBackPtr, kPartSizeText, tempNumStr, "\p", "\p" );
  381.         
  382.             // -- Target Total Size
  383.             NumToString( pExtenderPBPtr->fBasicPBRec.fCopyPBHeader.fTotalTargetSize, &tempNumStr );
  384.             PrintLine( theCallBackPtr, kTotalSizeText, tempNumStr, "\p", "\p" );
  385.                             
  386.             // -- Installer Temp Dir ID
  387.             if( pExtenderPBPtr->fBasicPBRec.fCopyPBHeader.fInstallerTempDirID != -1 ) {
  388.                 tempFSSpec.name[0] = 0;
  389.                 tempFSSpec.parID = pExtenderPBPtr->fBasicPBRec.fCopyPBHeader.fInstallerTempDirID;
  390.                 tempFSSpec.vRefNum = pExtenderPBPtr->fBasicPBRec.fCopyPBHeader.fTargetFile.vRefNum;
  391.                 MakeFilePath( &(tempFSSpec), tempStr255 );
  392.                 PrintLine( theCallBackPtr, kInstallerTempDirIDText, tempStr255, "\p", "\p" );
  393.             }
  394.  
  395.             break;
  396.             
  397.         }
  398.  
  399. // -- ATOM TARGET SPECIFIC INFO ----------------------------------------------------------------------
  400.  
  401.     switch (pExtenderPBPtr->fBasicPBRec.fEnvironmentHeader.fMessageID) {
  402.         case kInitialize :
  403.         case kSuccess :
  404.             break;
  405.         case kBeforePart :
  406.         case kAfterPart :
  407.             switch (pExtenderPBPtr->fBasicPBRec.fEnvironmentHeader.fDataType) {
  408.                 case kFileAtomDataFork :
  409.                 case kFileAtomRsrcFork :
  410.                 case kFileAtomRsrcForkFromDataFork :
  411.                     break;
  412.                 case kRsrcAtom :
  413.                     // -- Resource Target Type
  414.                     BlockMove( &(pExtenderPBPtr->fRsrcCopyPBRec.fTargetRsrcType), &(tempStr255[2]), 4 );
  415.                     tempStr255[1] = '\'';
  416.                     tempStr255[6] = '\'';
  417.                     tempStr255[0] = 6;
  418.                     PrintLine( theCallBackPtr, kRsrcTargetRsrcTypeText, tempStr255, "\p", "\p" );
  419.                     
  420.                     // -- Resource Target ID
  421.                     NumToString( pExtenderPBPtr->fRsrcCopyPBRec.fTargetRsrcID, &tempNumStr );
  422.                     PrintLine( theCallBackPtr, kRsrcTargetRsrcIDText, tempNumStr, "\p", "\p" );
  423.  
  424.                     // -- Resource Target Name
  425.                     PrintLine( theCallBackPtr, kRsrcTargetRsrcNameText, pExtenderPBPtr->fRsrcCopyPBRec.fTargetRsrcName, "\p", "\p" );
  426.  
  427.                     // -- Resource Target Attributes
  428.                     NumToString( pExtenderPBPtr->fRsrcCopyPBRec.fTargetRsrcAttrs, &tempNumStr );
  429.                     PrintLine( theCallBackPtr, kRsrcTargetRsrcAttrsText, tempNumStr, "\p", "\p" );
  430.  
  431.                     break;
  432.                 case kFontAtom :
  433.                     // -- Font Target Type
  434.                     BlockMove( &(pExtenderPBPtr->fFontCopyPBRec.fTargetFontRsrcType), &(tempStr255[2]), 4 );
  435.                     tempStr255[1] = '\'';
  436.                     tempStr255[6] = '\'';
  437.                     tempStr255[0] = 6;
  438.                     PrintLine( theCallBackPtr, kFontTargetRsrcTypeText, tempStr255, "\p", "\p" );
  439.                     
  440.                     // -- Font Target ID
  441.                     if( pExtenderPBPtr->fBasicPBRec.fEnvironmentHeader.fMessageID == kAfterPart ) {
  442.                         NumToString( pExtenderPBPtr->fFontCopyPBRec.fTargetFontRsrcID, &tempNumStr );
  443.                         PrintLine( theCallBackPtr, kFontTargetRsrcIDText, tempNumStr, "\p", "\p" );
  444.                     }
  445.                     
  446.                     // -- Font Target Name
  447.                     PrintLine( theCallBackPtr, kFontTargetRsrcNameText, pExtenderPBPtr->fFontCopyPBRec.fTargetFontRsrcName, "\p", "\p" );
  448.  
  449.                     // -- Font Target Attributes
  450.                     NumToString( pExtenderPBPtr->fFontCopyPBRec.fTargetFontRsrcAttrs, &tempNumStr );
  451.                     PrintLine( theCallBackPtr, kFontTargetRsrcAttrsText, tempNumStr, "\p", "\p" );
  452.                     
  453.                     break;
  454.                 default :
  455.                     break;
  456.                 }
  457.             break;
  458.         case kCancel :
  459.                 break;
  460.         }
  461.         
  462.         
  463.         
  464. // -- RESULT INFO ----------------------------------------------------------------------
  465.     switch (pResultCode) {
  466.         case kFatalError :            PrintLine( theCallBackPtr, kEndCallPart1, kErrorRtnMessageText, kEndCallPart3, "\p" );
  467.                                     break;
  468.         case kContinueAsNormal :    PrintLine( theCallBackPtr, kEndCallPart1, kOkRtnMessageText, kEndCallPart3, "\p" );
  469.                                     break;
  470.         case kCancelInstallation :    PrintLine( theCallBackPtr, kEndCallPart1, kCancelRtnMessageText, kEndCallPart3, "\p" );
  471.                                     break;
  472.         case kCopiedData :            PrintLine( theCallBackPtr, kEndCallPart1, kCopiedDataMessageText, kEndCallPart3, "\p" );
  473.                                     break;
  474.         }
  475.  
  476.  
  477. }
  478.  
  479.  
  480. #include  "AtomExtenderCBGlue.c"
  481. #include  "ActionHandlerCBGlue.c"